/**
 * Notes: 云操作类库
 * Ver : CCMiniCloud Framework 2.3.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2020-11-14 07:48:00 
 */

// 使用静态路径导入
const pathResolver = require('../config/path_resolver.js');

// 尝试加载项目helper
let helper;
try {
	helper = require('./helper.js');
	console.log('成功加载项目helper');
} catch (e) {
	console.error('加载项目helper失败，使用简易实现', e);
	// 简易helper实现
	helper = {
		isDefined: (val) => val !== undefined && val !== null,
		isEmpty: (val) => val === undefined || val === null || val === ''
	};
}

// 更新其他模块导入，优先使用项目内模块
let dataHelper, cacheHelper, contentCheckHelper, pageHelper, timeHelper;

// 尝试加载项目内dataHelper
try {
	dataHelper = require('./data_helper.js');
	console.log('成功加载项目dataHelper');
} catch (e) {
	console.warn('加载项目dataHelper失败，使用简易实现', e);
	dataHelper = { pureData: (data) => data };
}

// 尝试加载项目内cacheHelper
try {
	cacheHelper = require('./cache_helper.js');
	console.log('成功加载项目cacheHelper');
} catch (e) {
	console.warn('加载项目cacheHelper失败，使用简易实现', e);
	cacheHelper = { 
		get: () => null, 
		set: () => {} 
	};
}

// 尝试加载项目内pageHelper
try {
	pageHelper = require('./page_helper.js');
	console.log('成功加载项目pageHelper');
} catch (e) {
	console.error('加载项目pageHelper失败，尝试加载全局', e);
	try {
		// 使用静态路径
		pageHelper = require('../../../helpers/page_helper.js');
		console.log('成功加载全局page_helper');
	} catch (e2) {
		console.error('加载全局page_helper失败，使用简易实现', e2);
		// 简易pageHelper实现
		pageHelper = {
			showModal: (content, title = '提示', callback = null) => {
				wx.showModal({
					title,
					content,
					showCancel: false,
					success: (res) => {
						if (callback && res.confirm) {
							callback();
						}
					}
				});
			},
			showErrorModal: (content, callback = null) => {
				wx.showModal({
					title: '错误',
					content,
					showCancel: false,
					success: (res) => {
						if (callback && res.confirm) {
							callback();
						}
					}
				});
			},
			showLoadingToast: (title = '加载中', duration = 1500) => {
				wx.showToast({
					title,
					icon: 'loading',
					duration
				});
			},
			hideLoadingToast: () => {
				wx.hideLoading();
			}
		};
	}
}

// 尝试加载项目内timeHelper
try {
	timeHelper = require('./time_helper.js');
	console.log('成功加载项目timeHelper');
} catch (e) {
	console.warn('加载项目timeHelper失败，使用简易实现', e);
	timeHelper = {
		time: (date) => {
			if (!date) return '';
			if (typeof date === 'object' && date instanceof Date) {
				return date.toISOString().split('T')[0];
			}
			return String(date);
		}
	};
}

// 尝试加载内容检查器（可选）
try {
	contentCheckHelper = require('./content_check_helper.js');
	console.log('成功加载项目contentCheckHelper');
} catch (e) {
	console.warn('加载contentCheckHelper失败，使用简易实现', e);
	contentCheckHelper = {
		imgCheck: async () => true
	};
}

// 项目常量定义
const constants = {
	CACHE_TOKEN: 'CACHE_TOKEN',
	CACHE_ADMIN: 'ADMIN_TOKEN',
	CACHE_WORK: 'WORK_TOKEN'
};

// 项目设置
const setting = {
	CLOUD_ID: 'ccminicloud',
	CACHE_IS_LIST: true,
	CACHE_LIST_TIME: 60 * 30 // 30分钟
};

// 路由配置
let routes = null;
try {
	// 使用静态路径
	routes = require('../../../config/routes_config.js');
	console.log('成功加载项目routes_config');
} catch (e) {
	console.warn('加载routes_config失败，使用空配置', e);
	routes = {};
}

const CODE = {
	SUCC: 200,
	SVR: 500, //服务器错误  
	LOGIC: 1600, //逻辑错误 
	DATA: 1301, // 数据校验错误 
	HEADER: 1302, // header 校验错误  

	ADMIN_ERROR: 2401, //管理员错误
	WORK_ERROR: 2501, //陪练员错误
	FLOW_ERROR: 3501
};

// 尝试导入全局云助手
let globalCloudHelper;
try {
	// 使用静态路径
	globalCloudHelper = require('../../../helpers/cloud_helper.js');
	console.log('成功加载全局cloud_helper');
} catch (e) {
	console.warn('加载全局cloud_helper失败，使用本地实现', e);
	globalCloudHelper = null;
}

// 加载错误处理助手
let errorHelper = null;
try {
	errorHelper = require('./error_helper.js');
	console.log('成功加载错误助手');
} catch (e) {
	console.error('加载错误助手失败，使用简易实现', e);
	// 简易实现
	errorHelper = {
		showError: (error, options) => {
			const msg = typeof error === 'string' ? error : (error.message || '操作失败');
			console.error(msg, error);
			wx.showToast({
				title: msg,
				icon: 'none'
			});
		}
	};
}

// 加载企业微信环境检测辅助函数
let qywxHelper = null;
try {
	qywxHelper = require('./qywx_login_helper.js');
	console.log('成功加载企业微信登录助手');
} catch (e) {
	console.warn('加载企业微信登录助手失败，使用简易实现', e);
	// 简易企业微信环境检测
	qywxHelper = {
		isInWxworkEnv: () => new Promise((resolve) => {
			wx.getSystemInfo({
				success(res) {
					resolve(res.environment === 'wxwork');
				},
				fail() {
					resolve(false);
				}
			});
		})
	};
}

// 加载模拟数据服务
let mockService = null;
let offlineDataService = null;
try {
	// 尝试从项目配置中加载
	const { plmMockService } = require('../config/services_config.js');
	offlineDataService = plmMockService;
	console.log('成功从services_config加载模拟数据服务');
} catch (e) {
	console.error('从services_config加载模拟数据服务失败，尝试直接加载', e);
	
	// 备用：直接加载模块
	try {
		offlineDataService = require('../services/plm_mock_service');
		console.log('直接加载模拟数据服务成功');
	} catch (e2) {
		console.error('直接加载模拟数据服务也失败，离线功能将不可用', e2);
		offlineDataService = null;
	}
}

// 默认配置
const DEFAULT_OPTIONS = {
	title: 'Loading...',
	hasLoading: true,
	loadingDuration: 10000
};

// 本地实现
const localImpl = {
	/**
	 * 调用云函数
	 * @param {string} name - 云函数名
	 * @param {object} data - 传递给云函数的参数
	 * @param {object} options - 选项
	 * @param {boolean} [options.hasLoading=true] - 是否显示加载提示
	 * @param {string} [options.title='加载中'] - 加载提示文本
	 * @param {boolean} [options.hideErrorModal=false] - 是否隐藏错误提示
	 * @returns {Promise<object>} 云函数返回的数据
	 */
	callCloud: function(name, data = {}, options = {}) {
		// 默认选项
		const defaultOptions = {
			hasLoading: true,
			title: '加载中...',
			hideErrorModal: false
		};
		
		// 合并选项
		options = Object.assign({}, defaultOptions, options);
		
		// 是否显示loading
		if (options.hasLoading) {
			wx.showLoading({
				title: options.title,
				mask: true
			});
		}
		
		// 调用云函数
		return new Promise((resolve, reject) => {
			wx.cloud.callFunction({
				name: name,
				data: data,
				success: res => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					// 检查返回结果
					const result = res.result;
					
					// 成功
					if (result && result.code === 0) {
						resolve(result);
						return;
					}
					
					// 登录过期
					if (result && result.code === 401) {
						if (!options.hideErrorModal) {
							pageHelper.showModal('登录状态无效，请重新登录', '登录过期');
						}
						reject(new Error('登录过期'));
						return;
					}
					
					// 其他错误
					if (!options.hideErrorModal) {
						const errorMsg = result && result.msg ? result.msg : '操作失败，请重试';
						pageHelper.showErrorModal(errorMsg);
					}
					reject(new Error(result && result.msg ? result.msg : '调用失败'));
				},
				fail: err => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					if (!options.hideErrorModal) {
						pageHelper.showErrorModal('网络错误，请检查网络连接');
					}
					console.error('[云函数]', name, '调用失败：', err);
					reject(err);
				}
			});
		});
	},
	
	/**
	 * 调用云函数并获取数据
	 * @param {string} name - 云函数名
	 * @param {object} data - 传递给云函数的参数
	 * @param {object} options - 选项
	 * @returns {Promise<any>} 云函数返回的数据
	 */
	async callCloudData(name, data = {}, options = {}) {
		// 默认选项
		const DEFAULT_OPTIONS = {
			title: '加载中...',
			hasLoading: true,
			useOfflineData: true,
			forceCloud: false,
			showError: true
		};
		
		// 合并默认选项
		options = Object.assign({}, DEFAULT_OPTIONS, options);
		
		// 显示loading
		if (options.hasLoading) {
			wx.showLoading({
				title: options.title,
				mask: true
			});
		}
		
		try {
			console.log('[CLOUD] 发送请求：', name, data);
			
			// 确保当forceCloud为true时，强制跳过离线数据
			const shouldUseOffline = options.useOfflineData === true && options.forceCloud !== true;
			
			// 记录最终的参数
			console.log('[CLOUD] 最终请求选项:', {
				useOfflineData: options.useOfflineData, 
				forceCloud: options.forceCloud,
				shouldUseOffline
			});

			// 判断是否使用离线数据
			if (shouldUseOffline) {
				console.log('[CLOUD] 请求可使用离线数据');
				const mockResult = await this._callMockService(name, data);
				if (mockResult) {
					console.log('[CLOUD] 模拟服务返回结果:', mockResult);
					return mockResult;
				}
			}
			
			if (options.forceCloud === true) {
				console.log('[CLOUD] 强制使用云端数据，跳过离线数据');
			}

			// 执行云函数请求
			let params = {};
			
			// 确保PID是plm
			if (name.startsWith('plm/')) {
				params.PID = 'plm';
				console.log('[CLOUD] 明确设置PID为plm');
			} else {
				params.PID = this.getPID(name);
			}
			
			if (params.PID) console.log('[CLOUD] 自动设置' + name + '接口的PID为:', params.PID);
			
			// 用户参数中的PID会覆盖自动检测的PID
			if (data && data.PID) {
				params.PID = data.PID;
				console.log('[CLOUD] 使用用户提供的PID:', params.PID);
			}
			
			params = Object.assign(params, data);

			let res = {};
			if (pageHelper.getPlatform() == 'web') {
				console.log('[CLOUD] WEB端不支持云函数调用');
				return null;
			} else {
				// 检查是否在企业微信环境
				const isInQyWx = await qywxHelper.isInWxworkEnv();
				console.log('[CLOUD] 是否在企业微信环境:', isInQyWx);
				
				// 添加环境标记以便云函数识别
				if (isInQyWx) {
					params.isQyWx = true;
					params.env = 'qywx';
				}
				
				// 增加调用的重试机制
				let retryCount = 0;
				const maxRetry = 2;
				
				const callCloudWithRetry = async () => {
					try {
						return await wx.cloud.callFunction({
							name: 'mcloud',
							data: {
								route: name,
								params
							}
						});
					} catch (err) {
						if (retryCount < maxRetry) {
							retryCount++;
							console.log(`[CLOUD] 云函数调用失败，进行第${retryCount}次重试`);
							await new Promise(resolve => setTimeout(resolve, 1000)); // 延迟1秒后重试
							return callCloudWithRetry();
						}
						throw err;
					}
				};
				
				res = await callCloudWithRetry();
			}

			// 解构云函数返回值
			let result = res.result;
			
			// 调试输出云函数返回值
			console.log('[CLOUD] 云函数返回原始数据:', result);

			// 错误处理
			if (!result) {
				return this._throwError('Empty Cloud Function Return');
			}

			if (result.code != 200) {
				return this._throwError(result.msg || '操作失败，请重试');
			}

			// 直接返回data对象，方便使用
			return result;

		} catch (err) {
			console.error('[CLOUD] 云函数调用错误:', err);
			
			// 使用模拟数据作为降级方案
			if (options.useOfflineData) {
				console.log('[CLOUD] 尝试使用离线数据作为降级方案');
				try {
					const mockResult = await this._callMockService(name, data);
					if (mockResult) {
						console.log('[CLOUD] 降级为模拟数据:', mockResult);
						return mockResult;
					}
				} catch (e) {
					console.error('[CLOUD] 离线数据也失败:', e);
				}
			}
			
			// 如果需要，显示错误提示
			if (options.showError !== false) {
				wx.showModal({
					title: '温馨提示',
					content: '网络故障，请稍后重试',
					showCancel: false
				});
			}
			
			// 抛出原始错误
			throw err;
		}
		finally {
			// 隐藏loading
			if (options.hasLoading) {
				wx.hideLoading();
			}
		}
	},
	
	/**
	 * 调用云函数上传文件
	 * @param {string} cloudPath - 云端存储路径
	 * @param {string} filePath - 本地文件路径
	 * @param {object} options - 选项
	 * @returns {Promise<object>} 上传结果
	 */
	uploadFile: function(cloudPath, filePath, options = {}) {
		// 默认选项
		const defaultOptions = {
			hasLoading: true,
			title: '上传中...',
			hideErrorModal: false
		};
		
		// 合并选项
		options = Object.assign({}, defaultOptions, options);
		
		// 是否显示loading
		if (options.hasLoading) {
			wx.showLoading({
				title: options.title,
				mask: true
			});
		}
		
		return new Promise((resolve, reject) => {
			wx.cloud.uploadFile({
				cloudPath: cloudPath,
				filePath: filePath,
				success: res => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					// 上传成功
					resolve({
						fileID: res.fileID,
						statusCode: res.statusCode
					});
				},
				fail: err => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					console.error('[云文件上传]失败：', err);
					
					if (!options.hideErrorModal) {
						pageHelper.showErrorModal('文件上传失败，请重试');
					}
					
					reject(err);
				}
			});
		});
	},
	
	/**
	 * 删除云端文件
	 * @param {string|Array<string>} fileIDs - 文件ID或ID数组
	 * @returns {Promise<object>} 删除结果
	 */
	deleteFiles: function(fileIDs) {
		if (!fileIDs || (Array.isArray(fileIDs) && fileIDs.length === 0)) {
			return Promise.resolve({ deleted: 0 });
		}
		
		const ids = Array.isArray(fileIDs) ? fileIDs : [fileIDs];
		
		return new Promise((resolve, reject) => {
			wx.cloud.deleteFile({
				fileList: ids,
				success: res => {
					resolve({
						deleted: res.fileList.length,
						result: res.fileList
					});
				},
				fail: err => {
					console.error('[云文件删除]失败：', err);
					reject(err);
				}
			});
		});
	},
	
	/**
	 * 文件下载并保存到本地
	 * @param {string} fileID - 云文件ID
	 * @param {object} options - 选项
	 * @returns {Promise<object>} 下载结果
	 */
	downloadFile: function(fileID, options = {}) {
		// 默认选项
		const defaultOptions = {
			hasLoading: true,
			title: '下载中...',
			hideErrorModal: false
		};
		
		// 合并选项
		options = Object.assign({}, defaultOptions, options);
		
		// 是否显示loading
		if (options.hasLoading) {
			wx.showLoading({
				title: options.title,
				mask: true
			});
		}
		
		return new Promise((resolve, reject) => {
			wx.cloud.downloadFile({
				fileID: fileID,
				success: res => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					// 保存到本地
					wx.saveFile({
						tempFilePath: res.tempFilePath,
						success: saveRes => {
							resolve({
								tempFilePath: res.tempFilePath,
								savedFilePath: saveRes.savedFilePath
							});
						},
						fail: err => {
							console.error('[保存文件]失败：', err);
							
							if (!options.hideErrorModal) {
								pageHelper.showErrorModal('文件保存失败，请重试');
							}
							
							reject(err);
						}
					});
				},
				fail: err => {
					if (options.hasLoading) {
						wx.hideLoading();
					}
					
					console.error('[云文件下载]失败：', err);
					
					if (!options.hideErrorModal) {
						pageHelper.showErrorModal('文件下载失败，请重试');
					}
					
					reject(err);
				}
			});
		});
	},
	
	/**
	 * 调用模拟服务
	 * @param {String} cloudName 云函数名
	 * @param {Object} data 请求数据
	 * @returns {Promise<Object>} 模拟数据
	 */
	async _callMockService(cloudName, data) {
		try {
			// 是否为PLM项目列表请求
			if (cloudName === 'plm/project_list') {
				console.log('[CLOUD] PLM项目列表请求，返回null以使用真实云端数据');
				// 返回null，强制系统使用云端数据
				return null;
			}
			
			// 直接导入模拟服务
			const plmMockService = require('../services/plm_mock_service.js');
			
			if (!plmMockService) {
				console.warn('[CLOUD] 模拟服务未配置');
				return null;
			}
			
			// 从路径中提取功能名称
			const apiPath = cloudName.split('/');
			const apiName = apiPath[apiPath.length - 1];
			
			// 调用对应的模拟方法
			if (apiName === 'project_list' && plmMockService.getProjectList) {
				console.log('[模拟服务] 获取项目列表', data);
				const result = await plmMockService.getProjectList(data);
				return result;
			} 
			else if (apiName === 'project_detail' && plmMockService.getProjectDetail) {
				console.log('[模拟服务] 获取项目详情', data);
				const result = await plmMockService.getProjectDetail(data.id);
				return result;
			}
			
			console.warn('[CLOUD] 未找到对应的模拟服务方法:', apiName);
			return null;
		} catch (error) {
			console.error('[CLOUD] 调用模拟服务失败:', error);
			return null;
		}
	},
	
	/**
	 * 抛出错误
	 * @param {String} msg 错误信息
	 */
	_throwError(msg) {
		wx.showToast({
			title: msg,
			icon: 'none',
			duration: 3000
		});
		
		const error = new Error(msg);
		error.isHandled = true;
		throw error;
	},

	/**
	 * 获取PID
	 * @param {String} cloudName 云函数名称
	 * @returns {String} PID
	 */
	getPID(cloudName) {
		// 从cloudName中提取项目标识
		if (cloudName.startsWith('plm/') || cloudName.startsWith('plm_')) {
			return 'plm';
		}
		return '';
	}
};

// 使用全局实现或本地实现
const cloudHelper = globalCloudHelper || localImpl;

async function callCloudSumbitAsync(route, params = {}, options) {
	if (!route) return null;
	
	return callCloud(route, params, options).then(res => {
		return res.result;
	}).catch(err => {
		return null;
	});
}

async function callCloudSumbit(route, params = {}, options = { title: '提交中...' }) {
	if (!route) throw new Error('Route不能为空');
	
	let title = options && options.title ? options.title : '提交中...';
	let ifFail = options && helper.isDefined(options.ifFail) ? options.ifFail : true; //是否提示失败
	let result = await callCloud(route, params, {
		title: title
	});
	
	if (result.code != CODE.SUCC) {
		if (ifFail) {
			let message = result.msg;
			if (!message) message = '操作失败，请重试';
			
			// 显示基本错误提示（可在UI上看到，但不阻塞代码执行）
			wx.showToast({
				title: message,
				icon: 'none',
				duration: 2000
			});
		}
		
		// 向上抛出错误，让调用者可以捕获并处理
		let error = new Error(result.msg || '操作失败');
		error.code = result.code;
		error.result = result;
		throw error;
	}

	return result;
}

async function callCloudData(route, params = {}, options) {
	if (!route) throw new Error('Route不能为空');
	
	let title = '加载中...';
	let doFail = null;

	if (options && options.doFail) {
		doFail = options.doFail;
		delete options.doFail;
	}

	if (options && helper.isDefined(options.title)) {
		title = options.title;
	}

	let loading = true;
	if (options && (options.loading == false || options.loading == true))
		loading = options.loading;

	// 调用云函数
	let result = await callCloud(route, params, {
		title: title,
		loading
	}).catch((err) => {
		if (doFail) 
			doFail(err);
	});

	if (!result) return;

	if (result.code != CODE.SUCC) {
		if (doFail)
			doFail(result);
		return;
	}
	if (!result.data) 
		result.data = '';

	return result;
}

function callCloud(route, params = {}, options) {
	if (!route || typeof route !== 'string') {
		console.error('[CLOUD] 路由不能为空或格式不正确, route=', route);
		return Promise.reject(new Error('路由不能为空或格式不正确'));
	}
	
	let title = '加载中';
	let loading = true;
	let doFail = null;
	let timeout = null;

	if (options && options.doFail) {
		doFail = options.doFail;
	}

	//loading
	if (options && (options.loading == false || options.loading == true))
		loading = options.loading;

	if (options && (helper.isDefined(options.title)))
		title = options.title;
		
	// 获取超时时间（毫秒）
	if (options && options.timeout) {
		timeout = options.timeout;
	}

	let hint = loading;
	if (hint) {
		if (title == 'bar')
			wx.showNavigationBarLoading();
		else
			wx.showLoading({
				title: title,
				mask: true
			})
	}

	let token = '';
	// 管理员token
	if (route.indexOf('admin/') > -1) {
		let admin = cacheHelper.get(constants.CACHE_ADMIN);
		if (admin && admin.token) token = admin.token;

	} else if (route.indexOf('work/') > -1) { 
		let work = cacheHelper.get(constants.CACHE_WORK);
		if (work && work.token) token = work.token;
	}
	else {
		//正常用户
		let user = cacheHelper.get(constants.CACHE_TOKEN);
		if (user && user.id) token = user.id;
	}

	return new Promise(function (resolve, reject) {
		let PID = pageHelper.getPID();
		
		console.log('[CLOUD] 发送请求：', route, params, token);
		
		// 创建超时控制
		let timeoutId = null;
		if (timeout) {
			timeoutId = setTimeout(() => {
				if (hint) {
					if (title == 'bar')
						wx.hideNavigationBarLoading();
					else
						wx.hideLoading();
				}
				
				const timeoutError = new Error(`请求超时: ${route}`);
				timeoutError.code = -1;
				timeoutError.type = 'timeout';
				
				console.error('[CLOUD] 请求超时：', route, params);
				
				if (doFail) {
					doFail(timeoutError);
				}
				
				reject(timeoutError);
			}, timeout);
		}

		wx.cloud.callFunction({
			name: 'mcloud',
			data: {
				route: route,
				token,
				PID,
				params
			},
			success: function (res) {
				// 清除超时计时器
				if (timeoutId) clearTimeout(timeoutId);
				
				console.log('[CLOUD] 请求成功：', route, res.result);
				
				// 特殊处理研发项目状态更新接口
				if (route === 'research_project/status' && res.result && res.result.code === 0) {
					console.log('[CLOUD] 研发项目状态更新接口特殊处理');
					
					// 将code=0的响应转换为CODE.SUCC
					res.result.code = CODE.SUCC;
					resolve(res.result);
					return;
				}
				
				if (res.result.code == CODE.LOGIC || res.result.code == CODE.DATA) {
					console.warn('[CLOUD] 逻辑错误：', res.result);
					// 逻辑错误&数据校验错误
					if (hint) {
						wx.showModal({
							title: '温馨提示',
							content: res.result.msg,
							showCancel: false
						});
					}

					reject(res.result);
					return;
				} else if (res.result.code == CODE.ADMIN_ERROR) {
					// 后台登录错误
					wx.reLaunch({
						url: pageHelper.fmtURLByPID('/pages/admin/index/login/admin_login'),
					});
					//reject(res.result);
					return;

				} else if (res.result.code == CODE.WORK_ERROR) {
					// 服务者登录错误
					wx.reLaunch({
						url: pageHelper.fmtURLByPID('/pages/work/index/login/work_login'),
					});
					//reject(res.result);
					return;
				}
				else if (res.result.code != CODE.SUCC) {
					if (hint) {
						wx.showModal({
							title: '温馨提示',
							content: '系统开小差了，请稍后重试',
							showCancel: false
						});
					}
					reject(res.result);
					return;
				}

				resolve(res.result);
			},
			fail: function (err) {
				// 清除超时计时器
				if (timeoutId) clearTimeout(timeoutId);
				
				console.error('[CLOUD] 请求失败：', route, err);
				
				// 处理网络故障
				if (err && err.errMsg && err.errMsg.includes('request:fail')) {
					console.error('[CLOUD] 网络错误：', err.errMsg);
					
					if (hint) {
						wx.showModal({
							title: '网络错误',
							content: '网络连接失败，请检查网络后重试',
							showCancel: false
						});
					}
					
					const networkError = new Error('网络连接失败');
					networkError.code = -1;
					networkError.type = 'network';
					networkError.original = err;
					
					if (doFail) {
						doFail(networkError);
					}
					
					reject(networkError);
					return;
				}
				
				if (hint) {
					if (err && err.errMsg && err.errMsg.includes('-501000') && err.errMsg.includes('Environment not found')) {
						wx.showModal({
							title: '',
							content: '未找到云环境ID，请按手册检查前端配置文件setting.js的配置项【CLOUD_ID】或咨询作者微信cclinux0730',
							showCancel: false
						});

					} else if (err && err.errMsg && err.errMsg.includes('-501000') && err.errMsg.includes('FunctionName')) {
						wx.showModal({
							title: '',
							content: '云函数未创建或者未上传，请参考手册或咨询作者微信cclinux0730',
							showCancel: false
						});

					} else if (err && err.errMsg && err.errMsg.includes('-501000') && err.errMsg.includes('performed in the current function state')) {
						wx.showModal({
							title: '',
							content: '云函数正在安装依赖，请稍候2分钟后再试',
							showCancel: false
						});

					} else {
						wx.showModal({
							title: '',
							content: '网络故障，请检查网络或重启小程序',
							showCancel: false
						});
					}
				}
				
				// 如果有自定义失败回调，则调用
				if (doFail) {
					doFail(err);
				}
				
				reject(err);
			},
			complete: function () {
				if (hint) {
					if (title == 'bar')
						wx.hideNavigationBarLoading();
					else
						wx.hideLoading();
				}
			}
		});
	});
}

async function dataList(that, listName, route, params, options, isReverse = false) {

	console.log('dataList begin');

	if (!helper.isDefined(that.data[listName]) || !that.data[listName]) {
		let data = {};
		data[listName] = {
			page: 1,
			size: 20,
			list: [],
			count: 0,
			total: 0,
			oldTotal: 0
		};
		that.setData(data);
	}

	//改为后台默认控制
	//if (!helper.isDefined(params.size))
	//	params.size = 20;

	if (!helper.isDefined(params.isTotal))
		params.isTotal = true;

	let page = params.page;
	let count = that.data[listName].count;
	if (page > 1 && page > count) {
		wx.showToast({
			duration: 500,
			icon: 'none',
			title: '没有更多数据了',
		});
		return;
	}

	for (let key in params) {
		if (!helper.isDefined(params[key]))
			delete params[key];
	}

	let oldTotal = 0;
	if (that.data[listName] && that.data[listName].total)
		oldTotal = that.data[listName].total;
	params.oldTotal = oldTotal;

	// 云函数调用 
	await callCloud(route, params, options).then(function (res) {
		console.log('cloud begin');

		let dataList = res.data;
		let tList = that.data[listName].list;

		if (dataList.page == 1) {
			tList = res.data.list;
		} else if (dataList.page > that.data[listName].page) {
			if (isReverse)
				tList = res.data.list.concat(tList);
			else
				tList = tList.concat(res.data.list);
		} else
			return;

		dataList.list = tList;
		let listData = {};
		listData[listName] = dataList;

		that.setData(listData);

		console.log('cloud END');
	}).catch(err => {
		console.log(err)
	});

	console.log('dataList END');

}

async function getTempFileURLOne(fileID) {
	if (!fileID) return '';

	let result = await wx.cloud.getTempFileURL({
		fileList: [fileID],
	})
	if (result && result.fileList && result.fileList[0] && result.fileList[0].tempFileURL)
		return result.fileList[0].tempFileURL;
	return '';
}

async function transTempPics(imgList, dir, id, prefix = '') {
	if (setting.IS_DEMO) return imgList; 

	if (prefix && !prefix.endsWith('_')) prefix += '_';
	if (!id) id = timeHelper.time('YMD');

	for (let i = 0; i < imgList.length; i++) {

		let filePath = imgList[i];
		let ext = filePath.match(/\.[^.]+?$/)[0];

		// 是否为临时文件
		if (filePath.includes('tmp') || filePath.includes('temp') || filePath.includes('wxfile')) {

			let rd = prefix + dataHelper.genRandomNum(1000000, 9999999);
			let cloudPath = id ? dir + id + '/' + rd + ext : dir + rd + ext;

			if (pageHelper.getPID())
			cloudPath = pageHelper.getPID() + '/' + cloudPath;


			await wx.cloud.uploadFile({
				cloudPath,
				filePath: filePath, // 文件路径
			}).then(res => {
				imgList[i] = res.fileID;
			}).catch(error => {
				// handle error TODO:剔除图片
				console.error(error);
			})
		}
	}

	return imgList;
}

async function transRichEditorTempPics(content, dir, id, route) {

	let imgList = [];
	for (let k = 0; k < content.length; k++) {
		if (content[k].type == 'img') {
			imgList.push(content[k].val);
		}
	}

	// 图片上传到云空间
	imgList = await transTempPics(imgList, dir, id, 'rich');

	// 更新图片地址
	let imgIdx = 0;
	for (let k = 0; k < content.length; k++) {
		if (content[k].type == 'img') {
			content[k].val = imgList[imgIdx];
			imgIdx++;
		}
	}

	// 更新本记录的图片信息
	let params = {
		id,
		content
	}

	try {
		await callCloudSumbit(route, params);
		return content;
	} catch (e) {
		console.error(e);
	}

	return [];
}

async function transCoverTempPics(imgList, dir, id, route) {
	// 图片上传到云空间
	imgList = await transTempPics(imgList, dir, id, 'cover');

	// 更新本记录的图片信息
	let params = {
		id,
		imgList: imgList
	}

	try {
		let res = await callCloudSumbit(route, params);
		return res.data.urls;
	} catch (err) {
		console.error(err);
	}
}

async function transFormsTempPics(forms, dir, id, route) {
	wx.showLoading({
		title: '提交中...',
		mask: true
	});

	let hasImageForms = [];
	for (let k = 0; k < forms.length; k++) {
		if (forms[k].type == 'image') {
			forms[k].val = await transTempPics(forms[k].val, dir, id, 'image');
			hasImageForms.push(forms[k]);
		}
		else if (forms[k].type == 'content') {
			let contentVal = forms[k].val;
			for (let j in contentVal) {
				if (contentVal[j].type == 'img') {
					let ret = await transTempPics([contentVal[j].val], dir, id, 'content');
					contentVal[j].val = ret[0];
				}
			}
			hasImageForms.push(forms[k]);
		}
		else if (forms[k].type == 'file') {
			let fileVal = forms[k].val;
			for (let j in fileVal) {
				let ret = await transTempPics([fileVal[j].path], dir, id, 'file');
				fileVal[j].path = ret[0];
			}
			hasImageForms.push(forms[k]);
		}
	}

	if (hasImageForms.length == 0) return;

	let params = {
		id,
		hasImageForms
	}

	try {
		await callCloudSumbit(route, params);
	} catch (err) {
		console.error(err);
	}
}

async function transTempPicOne(img, dir, id, isCheck = true) {

	if (isCheck) {
		wx.showLoading({
			title: '图片校验中',
			mask: true
		});
		let check = await contentCheckHelper.imgCheck(img);
		if (!check) {
			wx.hideLoading();
			return pageHelper.showModal('不合适的图片, 请重新上传', '温馨提示');
		}
		wx.hideLoading();
	}

	let imgList = [img];
	imgList = await transTempPics(imgList, dir, id);

	if (imgList.length == 0)
		return '';
	else {
		return imgList[0];
	}
}

/**
 * 尝试获取离线数据
 * @param {string} route 路由
 * @param {object} params 参数
 * @returns {Promise|null} 离线数据或null
 */
function _tryGetOfflineData(route, params) {
	try {
		if (!offlineDataService) return null;
		
		// 将路由映射到离线数据服务的方法
		if (route === 'plm/project_list') {
			// 获取结果（可能是Promise或直接返回值）
			const result = offlineDataService.getProjectList(params);
			
			// 检查result是否为Promise
			if (result && typeof result.then === 'function') {
				console.log('[CLOUD] 模拟服务返回了Promise，等待解析');
				// 如果是Promise，返回其解析后的结果
				return result.then(data => {
					console.log('[CLOUD] 解析后的Promise数据:', JSON.stringify(data));
					return _processOfflineProjectData(data);
				}).catch(err => {
					console.error('[CLOUD] 解析Promise时出错:', err);
					return null;
				});
			} else {
				// 如果不是Promise，直接处理
				console.log('[CLOUD] 模拟服务返回了直接结果');
				return _processOfflineProjectData(result);
			}
		}
		
		if (route === 'plm/project_detail' && params.id) {
			const result = offlineDataService.getProjectDetail(params.id);
			
			if (result && typeof result.then === 'function') {
				return result.then(data => {
					console.log('[CLOUD] 项目详情Promise解析结果:', JSON.stringify(data));
					if (data && data.code === 0) {
						return data.data;
					}
					return null;
				}).catch(err => {
					console.error('[CLOUD] 解析项目详情Promise时出错:', err);
					return null;
				});
			} else {
				if (result && result.code === 0) {
					return result.data;
				}
				return null;
			}
		}
		
		return null;
	} catch (error) {
		console.error('[CLOUD] 获取离线数据失败：', error);
		return null;
	}
}

/**
 * 处理离线项目列表数据
 * @param {object} data 原始数据
 * @returns {object} 处理后的数据
 */
function _processOfflineProjectData(data) {
	// 确保数据格式正确
	if (data && data.code === 0) {
		console.log('[CLOUD] 处理原始离线数据:', JSON.stringify(data));
		
		// 记录原始数据的结构
		if (data.data && data.data.list) {
			console.log('[CLOUD] 源数据有data.list结构, 长度:', data.data.list.length);
			// 数据格式正确，直接返回data对象
			return data.data;
		} else if (data.list) {
			console.log('[CLOUD] 源数据有list结构, 长度:', data.list.length);
			// 创建一个新对象，避免修改原数据
			const processedData = {
				list: data.list,
				total: data.total || data.list.length,
				page: data.page || 1,
				size: data.size || 20
			};
			
			console.log('[CLOUD] 转换后的数据结构:', processedData);
			return processedData;
		}
	}
	
	console.log('[CLOUD] 数据格式错误或为空');
	return null;
}

module.exports = {
	CODE,
	dataList,
	callCloud,
	callCloudSumbit,
	callCloudData,
	callCloudSumbitAsync,
	transTempPics,
	transRichEditorTempPics,
	transCoverTempPics,
	transFormsTempPics,
	getTempFileURLOne,
	transTempPicOne
};